const express = require('express');
const router = express.Router();
const Ticket = require('../models/Ticket');
const Admin = require('../models/Admin');
const User = require('../models/User');
const Session = require('../models/Session');
const Message = require('../models/Message');
const authenticateToken = require('../middlewares/authenticateToken');
const checkRole = require('../middlewares/checkRole');

//获取客服列表（不限在线状态）6
router.get('/service/list', authenticateToken, async (req, res) => {
  try {
    const List=await Admin.find({role:'customer_service'})
    res.json({
      code: '0000',
      msg: '获取客服列表成功',
      data: List
    });
  } catch (err) {
    res.json({ code: '2001', msg: '获取客服列表失败: ' + err.message, data: null });
  }
});

//切换状态
router.put('/service/status', authenticateToken, async (req, res) => {
  try {
    const adminId = req.user.id;
    const { status } = req.body;

    const validStatus = ['online', 'offline', 'busy'];
    if (!status || !validStatus.includes(status)) {
      return res.status(400).json({
        code: '4000', // 自定义错误码，非0000表示失败
        success: false,
        message: `状态值不合法，必须是以下之一: ${validStatus.join(', ')}`
      });
    }

    const updatedAdmin = await Admin.findByIdAndUpdate(
      adminId,
      { status },
      { new: true, runValidators: true }
    );

    if (!updatedAdmin) {
      return res.status(404).json({
        code: '4040', // 自定义错误码
        success: false,
        message: '未找到当前用户'
      });
    }

    // 成功时返回 code: '0000'
    res.status(200).json({
      code: '0000',
      success: true,
      message: '状态切换成功',
      data: {
        adminId: updatedAdmin._id,
        username: updatedAdmin.username,
        status: updatedAdmin.status
      }
    });

  } catch (error) {
    console.error('状态切换失败:', error);
    res.status(500).json({
      code: '5000', // 自定义错误码
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : undefined
    });
  }
});

//获取单客服负责的作家列表
router.get('/service/authorList', authenticateToken, async (req, res) => {
  try {
    // 1. 从 Token 中获取当前客服的 ID（adminId）
    const adminId = req.user.id; // 假设 Token 解析后，req.user 包含客服的 _id（adminId）

    // 2. 查客服负责的会话 + 关联作家基本信息（User 模型）
    const sessions = await Session.find({
      serviceId: adminId, // 筛选客服的会话
      status: 'active'    // 可选：只显示“活跃”的会话，排除已关闭的
    })
    .populate({
      path: 'authorId',    // 关联 Session 的 authorId 字段
      model: 'User',       // 关联的模型是 User
      select: '_id nickname avatar' // 只取需要的字段（避免暴露密码等敏感信息）
    })
    .sort({ createTime: -1 }); // 按会话创建时间倒序（最新会话在前）

    // 3. 对每个会话，查 Message 统计未读消息数 + 最新消息
    const authorList = await Promise.all(
      sessions.map(async (session) => {
        // 3.1 统计未读消息数（作家发的、未读的）
        const unreadCount = await Message.countDocuments({
          sessionId: session._id,
          senderType: 'User',   // 发送方是作家（User 类型）
          isRead: false         // 未读状态
        });

        // 3.2 查最新一条消息（按发送时间倒序，取第一条）
        const latestMsg = await Message.findOne({
          sessionId: session._id
        })
        .sort({ sendTime: -1 }) // 倒序：最新的在前
        .select('content sendTime'); // 只取消息内容和时间

        // 3.3 组装单条作家列表数据
        return {
          authorId: session.authorId._id.toString(), // 作家 ID
          penName: session.authorId.nickname || '未知作家', // 作家笔名（来自 User）
          authorAvatar: session.authorId.avatar || '默认头像地址', // 作家头像（来自 User）
          sessionId: session._id.toString(), // 会话 ID（点击跳转聊天用）
          sessionStatus: session.status, // 会话状态（active/closed）
          unreadCount: unreadCount, // 未读消息数
          latestMsg: {
            content: latestMsg?.content || '暂无消息', // 最新消息内容
            sendTime: latestMsg?.sendTime || session.createTime // 最新消息时间（无则用会话创建时间）
          }
        };
      })
    );

    // 4. 返回最终的作家列表
    res.json({
      code: '0000',
      msg: '获取作家列表成功',
      data: {
        authorList: authorList,
        total: authorList.length // 总作家数（可选，用于分页）
      }
    });

  } catch (err) {
    res.json({
      code: '500',
      msg: '获取作家列表失败：' + err.message,
      data: null
    });
  }
});

//获取单个作家信息
router.get('/service/authorinfo', authenticateToken, async (req, res) => {
  try {

    const { authorId } = req.query;
    
    // 查询用户信息，排除密码字段
    const user = await User.findById(authorId).select('-password');
    
    if (!user) {
      return res.json({
        code: '2008',
        msg: '用户不存在',
        data: null
      });
    }
    
    res.json({
      code: '0000',
      msg: '获取用户信息成功',
      data: {
        id: user._id,
        username: user.username,
        nickname: user.nickname,
        email: user.email,
        avatar:user.avatar
        // 如果有其他字段也可以在这里返回
        // 等等...
      }
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '获取用户信息失败: ' + err.message,
      data: null
    });
  }
});

//发送消息
router.post('/service/send', authenticateToken, async (req, res) => {
  try {
    // 1. 接收请求体参数（严格匹配Message模型的必填字段）
    const {
      sessionId,
      senderType,
      senderId,
      receiverType,
      receiverId,
      content
    } = req.body;

    // 2. 校验必传参数（缺失则返回错误）
    if (!sessionId || !senderType || !senderId || !receiverType || !receiverId || !content) {
      return res.json({ code: '2021', msg: '会话ID、发送方/接收方信息、消息内容不能为空', data: null });
    }

    // 3. 校验senderType和receiverType是否符合枚举值（User/Admin）
    const validTypes = ['User', 'Admin'];
    if (!validTypes.includes(senderType) || !validTypes.includes(receiverType)) {
      return res.json({ code: '2022', msg: '发送方/接收方类型只能是User或Admin', data: null });
    }

    // 4. 校验关联的会话是否存在且活跃（避免往无效会话发消息）
    const session = await Session.findById(sessionId);
    if (!session) {
      return res.json({ code: '2023', msg: '会话不存在', data: null });
    }
    if (session.status !== 'active') {
      return res.json({ code: '2024', msg: '会话已关闭，无法发送消息', data: null });
    }

    // 5. 创建消息实例（自动填充默认值）
    const newMessage = new Message({
      sessionId,
      senderType,
      senderId,
      receiverType,
      receiverId,
      content,
      sendTime: new Date(), // 自动填充当前发送时间
      isRead: false // 默认未读（接收方未查看）
    });

    // 6. 保存消息到数据库
    await newMessage.save();

    // 7. 返回成功结果（包含完整消息信息）
    res.json({
      code: '0000',
      msg: '消息发送成功',
      data: {
        messageId: newMessage._id,
        sessionId: newMessage.sessionId,
        senderType: newMessage.senderType,
        senderId: newMessage.senderId,
        receiverType: newMessage.receiverType,
        receiverId: newMessage.receiverId,
        content: newMessage.content,
        sendTime: newMessage.sendTime,
        isRead: newMessage.isRead
      }
    });
  } catch (err) {
    res.json({ code: '2025', msg: '消息发送失败: ' + err.message, data: null });
  }
});

//获取历史聊天记录
router.get('/service/history', authenticateToken, async (req, res) => {
  try {
    // 1. 接收查询参数（sessionId必传，分页参数可选）
    const {
      sessionId,
      page = 1, // 默认第1页
      pageSize = 20 // 默认每页20条
    } = req.query;

    // 2. 校验sessionId必传
    if (!sessionId) {
      return res.json({ code: '2031', msg: '会话ID不能为空', data: null });
    }

    // 3. 校验会话是否存在（避免查询无效会话）
    const session = await Session.findById(sessionId);
    if (!session) {
      return res.json({ code: '2032', msg: '会话不存在', data: null });
    }

    // 4. 分页计算（skip：跳过前面的条数，limit：当前页最大条数）
    const skip = (page - 1) * pageSize;

    // 5. 查询历史消息（按发送时间倒序，关联会话）
    const messages = await Message.find({ sessionId })
      .sort({ sendTime: 1 }) //1：正序（最早消息在前）
      .skip(skip)
      .limit(Number(pageSize))
      .lean(); // lean()：返回纯JS对象，性能更好

    // 6. 查询总消息数（用于前端分页控件计算总页数）
    const total = await Message.countDocuments({ sessionId });

    // 7. 返回结果（包含消息列表和分页信息）
    res.json({
      code: '0000',
      msg: '历史消息查询成功',
      data: {
        list: messages, // 当前页消息列表
        pagination: {
          page: Number(page),
          pageSize: Number(pageSize),
          total, // 总消息数
          totalPage: Math.ceil(total / pageSize) // 总页数
        }
      }
    });
  } catch (err) {
    res.json({ code: '2033', msg: '历史消息查询失败: ' + err.message, data: null });
  }
});

module.exports = router;